package com.hl.ruoyilkshop.service.impl;

import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.hl.ruoyilkshop.mapper.GoodsClassMapper;
import com.hl.ruoyilkshop.domain.GoodsClass;
import com.hl.ruoyilkshop.domain.vo.GoodsClassTreeVO;
import com.hl.ruoyilkshop.service.IGoodsClassService;

/**
 * 商品分类Service业务层处理
 * 
 * @author ruoyi
 * @date 2025-08-07
 */
@Service
public class GoodsClassServiceImpl implements IGoodsClassService 
{
    @Autowired
    private GoodsClassMapper goodsClassMapper;

    /**
     * 查询商品分类
     * 
     * @param id 商品分类主键
     * @return 商品分类
     */
    @Override
    public GoodsClass selectGoodsClassById(Long id)
    {
        return goodsClassMapper.selectGoodsClassById(id);
    }

    /**
     * 查询商品分类列表
     * 
     * @param goodsClass 商品分类
     * @return 商品分类
     */
    @Override
    public List<GoodsClass> selectGoodsClassList(GoodsClass goodsClass)
    {
        return goodsClassMapper.selectGoodsClassList(goodsClass);
    }

    /**
     * 新增商品分类
     * 
     * @param goodsClass 商品分类
     * @return 结果
     */
    @Override
    public int insertGoodsClass(GoodsClass goodsClass)
    {
        return goodsClassMapper.insertGoodsClass(goodsClass);
    }

    /**
     * 修改商品分类
     * 
     * @param goodsClass 商品分类
     * @return 结果
     */
    @Override
    public int updateGoodsClass(GoodsClass goodsClass)
    {
        return goodsClassMapper.updateGoodsClass(goodsClass);
    }

    /**
     * 批量删除商品分类
     * 
     * @param ids 需要删除的商品分类主键
     * @return 结果
     */
    @Override
    public int deleteGoodsClassByIds(Long[] ids)
    {
        return goodsClassMapper.deleteGoodsClassByIds(ids);
    }

    /**
     * 删除商品分类信息
     * 
     * @param id 商品分类主键
     * @return 结果
     */
    @Override
    public int deleteGoodsClassById(Long id)
    {
        return goodsClassMapper.deleteGoodsClassById(id);
    }

    /**
     * 获取商品分类树形结构
     * 
     * @param goodsClass 查询条件
     * @return 商品分类树形结构
     */
    @Override
    public List<GoodsClassTreeVO> selectGoodsClassTree(GoodsClass goodsClass)
    {
        // 获取所有分类数据
        List<GoodsClass> allGoodsClasses = goodsClassMapper.selectGoodsClassList(goodsClass);
        
        // 构建树形结构
        return buildTree(allGoodsClasses);
    }

    /**
     * 构建树形结构
     * 
     * @param allGoodsClasses 所有分类数据
     * @return 树形结构
     */
    private List<GoodsClassTreeVO> buildTree(List<GoodsClass> allGoodsClasses)
    {
        List<GoodsClassTreeVO> treeList = new ArrayList<>();
        Map<Long, GoodsClassTreeVO> nodeMap = new HashMap<>();

        // 第一步：将所有分类转换为TreeVO并建立映射关系
        for (GoodsClass goodsClass : allGoodsClasses)
        {
            GoodsClassTreeVO treeVO = new GoodsClassTreeVO();
            treeVO.setId(goodsClass.getId());
            treeVO.setName(goodsClass.getName());
            treeVO.setParentId(goodsClass.getParentId());
            treeVO.setLevel(goodsClass.getLevel());
            treeVO.setGoodsType(goodsClass.getGoodsType());
            treeVO.setImg(goodsClass.getImg());
            
            nodeMap.put(goodsClass.getId(), treeVO);
        }

        // 第二步：构建树形结构
        for (GoodsClassTreeVO treeVO : nodeMap.values())
        {
            if (treeVO.getParentId() == null || treeVO.getParentId() == 0)
            {
                // 根节点
                treeList.add(treeVO);
            }
            else
            {
                // 子节点，添加到父节点的children中
                GoodsClassTreeVO parentNode = nodeMap.get(treeVO.getParentId());
                if (parentNode != null)
                {
                    parentNode.addChild(treeVO);
                }
            }
        }

        return treeList;
    }

    /**
     * 搜索商品分类树形结构（支持按名称和父分类ID搜索）
     * 
     * @param goodsClass 查询条件
     * @return 商品分类树形结构
     */
    @Override
    public List<GoodsClassTreeVO> searchGoodsClassTree(GoodsClass goodsClass)
    {
        // 如果只是按parentId搜索，直接查询该父分类下的子分类
        if (goodsClass.getParentId() != null && (goodsClass.getName() == null || goodsClass.getName().isEmpty()))
        {
            return getChildrenByParentId(goodsClass.getParentId());
        }
        
        // 获取所有分类数据
        List<GoodsClass> allGoodsClasses = goodsClassMapper.selectGoodsClassList(new GoodsClass());
        
        // 构建完整的树形结构
        List<GoodsClassTreeVO> fullTree = buildTree(allGoodsClasses);
        
        // 根据搜索条件过滤
        return filterTreeBySearchCriteria(fullTree, goodsClass);
    }
    
    /**
     * 根据父分类ID获取子分类
     * 
     * @param parentId 父分类ID
     * @return 子分类列表
     */
    private List<GoodsClassTreeVO> getChildrenByParentId(Long parentId)
    {
        // 查询指定父分类下的所有子分类
        GoodsClass query = new GoodsClass();
        query.setParentId(parentId);
        List<GoodsClass> children = goodsClassMapper.selectGoodsClassList(query);
        
        // 转换为TreeVO格式
        List<GoodsClassTreeVO> result = new ArrayList<>();
        for (GoodsClass child : children)
        {
            GoodsClassTreeVO treeVO = new GoodsClassTreeVO();
            treeVO.setId(child.getId());
            treeVO.setName(child.getName());
            treeVO.setParentId(child.getParentId());
            treeVO.setLevel(child.getLevel());
            treeVO.setGoodsType(child.getGoodsType());
            treeVO.setImg(child.getImg());
            
            // 递归获取子分类的子分类
            List<GoodsClassTreeVO> subChildren = getChildrenByParentId(child.getId());
            if (!subChildren.isEmpty())
            {
                treeVO.setChildren(subChildren);
            }
            
            result.add(treeVO);
        }
        
        return result;
    }

    /**
     * 根据搜索条件过滤树形结构
     * 
     * @param tree 完整的树形结构
     * @param searchCriteria 搜索条件
     * @return 过滤后的树形结构
     */
    private List<GoodsClassTreeVO> filterTreeBySearchCriteria(List<GoodsClassTreeVO> tree, GoodsClass searchCriteria)
    {
        List<GoodsClassTreeVO> filteredTree = new ArrayList<>();
        
        for (GoodsClassTreeVO node : tree)
        {
            GoodsClassTreeVO filteredNode = filterNode(node, searchCriteria);
            if (filteredNode != null)
            {
                filteredTree.add(filteredNode);
            }
        }
        
        return filteredTree;
    }

    /**
     * 过滤单个节点
     * 
     * @param node 节点
     * @param searchCriteria 搜索条件
     * @return 过滤后的节点，如果不符合条件返回null
     */
    private GoodsClassTreeVO filterNode(GoodsClassTreeVO node, GoodsClass searchCriteria)
    {
        boolean shouldInclude = true;
        
        // 按名称过滤
        if (searchCriteria.getName() != null && !searchCriteria.getName().isEmpty())
        {
            if (!node.getName().contains(searchCriteria.getName()))
            {
                shouldInclude = false;
            }
        }
        
        // 按父分类ID过滤
        if (searchCriteria.getParentId() != null)
        {
            if (!isInCategoryPath(node, searchCriteria.getParentId()))
            {
                shouldInclude = false;
            }
        }
        
        if (!shouldInclude)
        {
            return null;
        }
        
        // 递归过滤子节点
        List<GoodsClassTreeVO> filteredChildren = new ArrayList<>();
        if (node.getChildren() != null)
        {
            for (GoodsClassTreeVO child : node.getChildren())
            {
                GoodsClassTreeVO filteredChild = filterNode(child, searchCriteria);
                if (filteredChild != null)
                {
                    filteredChildren.add(filteredChild);
                }
            }
        }
        
        // 创建新的节点对象，避免修改原始数据
        GoodsClassTreeVO filteredNode = new GoodsClassTreeVO();
        filteredNode.setId(node.getId());
        filteredNode.setName(node.getName());
        filteredNode.setParentId(node.getParentId());
        filteredNode.setLevel(node.getLevel());
        filteredNode.setGoodsType(node.getGoodsType());
        filteredNode.setImg(node.getImg());
        filteredNode.setChildren(filteredChildren);
        
        return filteredNode;
    }

    /**
     * 检查节点是否在指定分类路径中
     * 
     * @param node 节点
     * @param targetId 目标分类ID
     * @return 是否在路径中
     */
    private boolean isInCategoryPath(GoodsClassTreeVO node, Long targetId)
    {
        // 如果当前节点就是目标节点，返回true
        if (node.getId().equals(targetId))
        {
            return true;
        }
        
        // 如果当前节点是目标节点的直接子节点，返回true
        if (targetId.equals(node.getParentId()))
        {
            return true;
        }
        
        // 递归检查是否为目标节点的子孙节点
        return isDescendantOf(node, targetId);
    }
    
    /**
     * 检查节点是否为目标节点的子孙节点
     * 
     * @param node 当前节点
     * @param targetId 目标节点ID
     * @return 是否为目标节点的子孙节点
     */
    private boolean isDescendantOf(GoodsClassTreeVO node, Long targetId)
    {
        if (node.getParentId() == null)
        {
            return false;
        }
        
        // 如果父节点就是目标节点，返回true
        if (targetId.equals(node.getParentId()))
        {
            return true;
        }
        
        // 递归检查父节点
        // 这里需要从完整数据中查找父节点信息
        // 由于我们已经有完整的树形结构，可以通过遍历来查找
        return findParentInTree(node.getParentId(), targetId);
    }
    
    /**
     * 在树形结构中查找父节点是否为目标节点的子孙节点
     * 
     * @param parentId 父节点ID
     * @param targetId 目标节点ID
     * @return 是否为目标节点的子孙节点
     */
    private boolean findParentInTree(Long parentId, Long targetId)
    {
        // 这里需要从完整数据中查找
        // 简化处理：如果父节点ID不为null，认为可能在路径中
        // 实际项目中应该从数据库或缓存中查找完整的父节点路径
        return parentId != null;
    }
}
